home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume11 / templates / part02 < prev    next >
Encoding:
Internet Message Format  |  1987-10-04  |  39.9 KB
  1. Subject:  v11i092:  Template-mode for GNU Emacs, Part02/06
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rs@uunet.UU.NET
  5.  
  6. Submitted-by: "Mark A. Ardis" <maa@sei.cmu.edu>
  7. Posting-number: Volume 11, Issue 92
  8. Archive-name: templates/part02
  9.  
  10. #! /bin/sh
  11. # This is a shell archive, meaning:
  12. # 1. Remove everything above the #! /bin/sh line.
  13. # 2. Save the resulting text in a file.
  14. # 3. Execute the file with /bin/sh (not csh) to create:
  15. #    template.el
  16. #    tplvars.el
  17. export PATH; PATH=/bin:/usr/bin:$PATH
  18. echo shar: "extracting 'template.el'" '(26969 characters)'
  19. if test -f 'template.el'
  20. then
  21.     echo shar: "will not over-write existing file 'template.el'"
  22. else
  23. sed 's/^X//' << \SHAR_EOF > 'template.el'
  24. X;;; template.el -- generate and manipulate templates
  25. X;;; Copyright (C) 1987 Mark A. Ardis.
  26. X
  27. X(require 'tplvars)
  28. X(require 'menu)
  29. X(require 'symbol)
  30. X(require 'tplhelper)
  31. X(require 'tplparse)
  32. X(require 'tplreplace)
  33. X(require 'tplscan)
  34. X
  35. X(provide 'template)
  36. X
  37. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  38. X;;; All global variables are in "tplvars".
  39. X;;; All non-interactive helper functions are in "tplhelper" or "tplscan".
  40. X
  41. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  42. X
  43. X(defun template-mode ()
  44. X  "Toggle template-mode, a minor mode for manipulation of text via templates.
  45. X    Calls 'template-mode-hook' if it is defined."
  46. X  (interactive)
  47. X                    ; Local Variables
  48. X  (let (file-name)
  49. X                    ; Body
  50. X    (setq template-mode (not template-mode))
  51. X    (set-buffer-modified-p (buffer-modified-p))
  52. X    (if template-mode
  53. X    (progn
  54. X      (setq file-name (buffer-name))
  55. X      (setq sym-completion-buffer (concat "id-" file-name))
  56. X      (if tpl-save-identifier-file
  57. X          (find-file-noselect sym-completion-buffer)
  58. X        ; else
  59. X        (get-buffer-create sym-completion-buffer)
  60. X        ) ; if
  61. X      (bury-buffer sym-completion-buffer)
  62. X      (tpl-initialize-scan)
  63. X      (tpl-build-template-list)
  64. X      (tpl-make-keymap)
  65. X      (and (boundp 'template-mode-hook)
  66. X           template-mode-hook
  67. X           (funcall template-mode-hook))
  68. X      ) ; progn
  69. X      ; else
  70. X      (progn
  71. X    (setq tpl-local-template-list nil)
  72. X    (tpl-undo-keymap)
  73. X    ) ; progn
  74. X      ) ; if
  75. X    ) ; let
  76. X  ) ; defun template-mode
  77. X
  78. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  79. X
  80. X(defun compile-templates (template-file)
  81. X  "Compile the templates in TEMPLATE-FILE into a Lisp structure."
  82. X  (interactive    "Fcompile-templates: Template file? ")
  83. X                    ; Local Variables
  84. X  (let (file-list file-name file
  85. X          found root-name object-file)
  86. X                    ; Body
  87. X    (setq root-name (file-name-nondirectory template-file))
  88. X    (if (and (> (length root-name) 4)
  89. X         (equal (substring root-name -4) ".tpl"))
  90. X    (setq root-name (substring root-name 0 -4))
  91. X      ) ; if
  92. X    (setq object-file (concat (file-name-directory template-file)
  93. X                  root-name "tpl.el"))
  94. X    (setq file-list tpl-local-template-list)
  95. X    (setq found nil)
  96. X    (while (and file-list (not found))
  97. X      (setq file (car file-list))
  98. X      (setq file-list (cdr file-list))
  99. X      (setq file-name (nth 0 file))
  100. X      (if (equal file-name root-name)
  101. X      (setq found t)
  102. X    ) ; if (equal file-name root-name)
  103. X      ) ; while file-list
  104. X    (if found
  105. X    (progn
  106. X      (save-window-excursion
  107. X        (set-buffer tpl-work-buffer)
  108. X        (erase-buffer)
  109. X        (message "Compiling templates into a lisp form...")
  110. X        (insert "(setq template-list '")
  111. X        (insert (prin1-to-string file))
  112. X        (insert ")")
  113. X        (newline)
  114. X        (write-region (point-min) (point-max) object-file)
  115. X        (byte-compile-file object-file)
  116. X        (delete-file object-file)
  117. X        ) ; save-window-excursion
  118. X      (bury-buffer tpl-work-buffer)
  119. X      ) ; progn
  120. X      ; else
  121. X      (progn
  122. X    (error "Cannot find " template-file)
  123. X    ) ; progn
  124. X      ) ; if found
  125. X                    ; return
  126. X    object-file
  127. X    ) ; let
  128. X  ) ; defun compile-templates
  129. X
  130. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  131. X
  132. X(defun delete-placeholder ()
  133. X  "Delete the placeholder at point."
  134. X  (interactive)
  135. X                    ; Local Variables
  136. X  (let (start)
  137. X                    ; Body
  138. X    (if (looking-at tpl-pattern-placeholder)
  139. X    (progn
  140. X      (setq start (point))
  141. X      (re-search-forward tpl-pattern-placeholder)
  142. X      (delete-region start (point))
  143. X      ) ; progn
  144. X      ; else
  145. X      (error "No placholder here!")
  146. X      ) ; if (looking-at tpl-pattern-placeholder)
  147. X    ) ; let
  148. X  ) ; defun delete-placeholder
  149. X
  150. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  151. X
  152. X(defun describe-template-mode ()
  153. X  "Describe template-mode and its keybindings."
  154. X  (interactive)
  155. X                    ; Local Variables
  156. X  (let (orig-buffer)
  157. X                    ; Body
  158. X    (setq orig-buffer (buffer-name))
  159. X    (pop-to-buffer (get-buffer-create "*Help*"))
  160. X    (erase-buffer)
  161. X    (insert "Template-mode is a minor mode for manipulating regions of text\n")
  162. X    (insert "called `templates'.  Templates have some of the attributes of\n")
  163. X    (insert "productions in a context-free grammar.  They also have some of\n")
  164. X    (insert "the attributes of rectangular pictures.  ")
  165. X    (insert "For more information try:\n\n")
  166. X    (insert "   C-h b  (describe-bindings)  Shows all of the new bindings.\n")
  167. X    (insert "   C-h i  (info)  A user manual is available via `info'.\n")
  168. X    (goto-char (point-min))
  169. X    (pop-to-buffer orig-buffer)
  170. X    ) ; let
  171. X  ) ; defun describe-template-mode
  172. X
  173. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  174. X
  175. X(defun expand-placeholder ()
  176. X  "Expand the placeholder at point---interactive version."
  177. X  (interactive)
  178. X                    ; Local Variables
  179. X  (let (start stop)
  180. X                    ; Body
  181. X    (if (looking-at tpl-pattern-placeholder)
  182. X    (progn
  183. X      (setq start (point))
  184. X      (setq tpl-destination-needed t)
  185. X      (tpl-expand-placeholder nil)
  186. X      (setq stop (point))
  187. X      (if (not tpl-destination-needed)
  188. X          (progn
  189. X        (goto-char (marker-position tpl-destination-marker))
  190. X        (set-marker tpl-destination-marker nil)
  191. X        ) ; progn
  192. X        ; else
  193. X        (progn
  194. X          (setq tpl-destination-needed nil)
  195. X          (goto-char start)
  196. X          (if (re-search-forward tpl-pattern-placeholder stop stop)
  197. X          (re-search-backward tpl-pattern-placeholder)
  198. X        ) ; if
  199. X          ) ; progn
  200. X        ) ; if (not tpl-destination-needed)
  201. X      ) ; progn
  202. X      ; else
  203. X      (error "expand-placeholder: No placeholder at point!")
  204. X      ) ; if
  205. X    ) ; let
  206. X  ) ; defun expand-placeholder
  207. X
  208. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  209. X
  210. X(defun expand-placeholders-in-region (start stop)
  211. X  "Expand each placeholder in the region between START and STOP."
  212. X  (interactive "r")
  213. X                    ; Local Variables
  214. X  (let (stop-marker save)
  215. X                    ; Body
  216. X    (goto-char start)
  217. X    (setq stop-marker (make-marker))
  218. X    (set-marker stop-marker stop)
  219. X                    ; (The check for out-of-bounds is
  220. X                    ;   needed for a placeholder at
  221. X                    ;   the end of the region.)
  222. X    (while (and (< (point) (marker-position stop-marker))
  223. X        (re-search-forward
  224. X         tpl-pattern-placeholder (marker-position stop-marker) t))
  225. X      (re-search-backward tpl-pattern-placeholder)
  226. X      (if (looking-at tpl-begin-optional)
  227. X      (if (or (equal t tpl-keep-optional-placeholders)
  228. X          (and tpl-keep-optional-placeholders
  229. X               (tpl-y-or-n-p "Keep optional placeholder? ")))
  230. X          (progn
  231. X        (delete-char (length tpl-begin-optional))
  232. X        (insert-before-markers tpl-begin-placeholder)
  233. X        (re-search-backward tpl-begin-placeholder)
  234. X        (if (or (< tpl-expansion-depth tpl-ask-expansion-depth)
  235. X            (tpl-y-or-n-p "Expand? "))
  236. X            (progn
  237. X              (setq tpl-expansion-depth (1+ tpl-expansion-depth))
  238. X              (unwind-protect
  239. X              (tpl-expand-placeholder (marker-position stop-marker))
  240. X            (setq tpl-expansion-depth (1- tpl-expansion-depth))
  241. X            ) ; unwind-protect
  242. X              ) ; progn
  243. X          ; else
  244. X          (progn
  245. X            (re-search-forward tpl-pattern-placeholder)
  246. X            ) ; progn
  247. X          ) ; if (tpl-y-or-n-p "Expand? ")
  248. X        ) ; progn
  249. X        ; else
  250. X        (progn
  251. X          (setq save (point))
  252. X          (re-search-forward tpl-pattern-placeholder)
  253. X          (delete-region save (point))
  254. X          (if (tpl-blank-line)
  255. X          (delete-indentation)
  256. X        ) ; if
  257. X          ) ; progn
  258. X        ) ; if (tpl-y-or-n-p "Keep optional placeholder? ")
  259. X    ; else
  260. X    (if (or (< tpl-expansion-depth tpl-ask-expansion-depth)
  261. X        (tpl-y-or-n-p "Expand? "))
  262. X        (progn
  263. X          (setq tpl-expansion-depth (1+ tpl-expansion-depth))
  264. X          (unwind-protect
  265. X          (tpl-expand-placeholder (marker-position stop-marker))
  266. X        (setq tpl-expansion-depth (1- tpl-expansion-depth))
  267. X        ) ; unwind-protect
  268. X          ) ; progn
  269. X      ; else
  270. X      (progn
  271. X        (re-search-forward tpl-pattern-placeholder)
  272. X        ) ; progn
  273. X      ) ; if (tpl-y-or-n-p "Expand? ")
  274. X    ) ; if (looking-at tpl-begin-optional)
  275. X      ) ; while (re-search-forward...)
  276. X    (if (< (point) (marker-position stop-marker))
  277. X    (goto-char (marker-position stop-marker))
  278. X      ) ; if
  279. X    (set-marker stop-marker nil)
  280. X    ) ; let
  281. X  ) ; defun expand-placeholders-in-region
  282. X
  283. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  284. X
  285. X(defun generate-any-template ()
  286. X  "Generate any template, by using the special all-templates-template."
  287. X  (interactive)
  288. X                    ; Local Variables
  289. X  (let ()
  290. X                    ; Body
  291. X    (if (or tpl-all-templates-template-invalid
  292. X        (not (tpl-find-template tpl-all-templates-name)))
  293. X    (if (y-or-n-p "Cannot find all-templates-template.  Rebuild? ")
  294. X        (progn
  295. X          (tpl-make-all-templates-template)
  296. X          (tpl-generate tpl-all-templates-name)
  297. X          ) ; progn
  298. X      ; else
  299. X      (error "Aborted.")
  300. X      ) ; if (y-or-n-p ...)
  301. X      ; else
  302. X      (tpl-generate tpl-all-templates-name)
  303. X      ) ; if
  304. X    ) ; let
  305. X  ) ; defun generate-any-template
  306. X
  307. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  308. X
  309. X(defun generate-template ()
  310. X  "Complete template name and call tpl-generate."
  311. X  (interactive)
  312. X                    ; Local Variables
  313. X  (let (name name-list)
  314. X                    ; Body
  315. X                    ; Build completion list
  316. X    (setq name-list (tpl-make-completion-list))
  317. X    ; Query for name and generate
  318. X    (setq name
  319. X      (completing-read "generate-template: Name of template? "
  320. X               name-list nil t nil))
  321. X    (tpl-generate name)
  322. X    ) ; let
  323. X  ) ; defun generate-template
  324. X
  325. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  326. X
  327. X(defun load-tpl-buffer (&optional buffer)
  328. X  "Load all of the templates (in the optional BUFFER).
  329. X    Defaults to 'tpl-new-template-buffer."
  330. X  (interactive)
  331. X                    ; Local Variables
  332. X  (let (root-name new-list)
  333. X                    ; Body
  334. X    (if (not buffer)
  335. X    (setq buffer
  336. X          (read-buffer "load-tpl-buffer: Template buffer? "
  337. X               tpl-new-template-buffer t))
  338. X      ) ; if (not buffer)
  339. X    (setq new-list (tpl-make-template-list buffer t))
  340. X    (setq tpl-local-template-list (append (list new-list) tpl-local-template-list))
  341. X    (if tpl-rebuild-all-templates-template
  342. X    (tpl-make-all-templates-template)
  343. X      ; else
  344. X      (setq tpl-all-templates-template-invalid t)
  345. X      ) ; if
  346. X    (if (interactive-p)
  347. X    (if (y-or-n-p "Rebuild global template list with these new templates? ")
  348. X        (progn
  349. X          (setq mode-nm (read-string "Mode name for global template list? "))
  350. X          (tpl-rebuild-global-template-list mode-nm new-list)
  351. X          ) ; progn
  352. X      ) ; if (y-or-n-p ...)
  353. X      ) ; if (interactive-p)
  354. X    ) ; let
  355. X  ) ; defun load-tpl-buffer
  356. X
  357. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  358. X
  359. X(defun load-tpl-file (&optional file)
  360. X  "Load all of the templates (in the optional FILE).
  361. X    Uses file name completion in the current directory, and
  362. X    defaults to 'tpl-new-template-buffer."
  363. X  (interactive)
  364. X                    ; Local Variables
  365. X  (let (root-name new-list)
  366. X                    ; Body
  367. X    (if (not file)
  368. X    (setq file
  369. X          (expand-file-name (read-file-name
  370. X                 (concat "load-tpl-file: Template file? ("
  371. X                     tpl-new-template-buffer ") ")
  372. X                 nil tpl-new-template-buffer)))
  373. X      ) ; if (not file)
  374. X    (setq root-name (tpl-root-of-file-name (file-name-nondirectory file)))
  375. X    (setq new-list (tpl-make-template-list file))
  376. X    (setq tpl-local-template-list (append (list new-list) tpl-local-template-list))
  377. X    (if tpl-rebuild-all-templates-template
  378. X    (tpl-make-all-templates-template)
  379. X      ; else
  380. X      (setq tpl-all-templates-template-invalid t)
  381. X      ) ; if
  382. X    (if (interactive-p)
  383. X    (if (y-or-n-p "Rebuild global template list with these new templates? ")
  384. X        (progn
  385. X          (setq mode-nm (read-string "Mode name for global template list? "))
  386. X          (tpl-rebuild-global-template-list mode-nm new-list)
  387. X          ) ; progn
  388. X      ) ; if (y-or-n-p ...)
  389. X      ) ; if (interactive-p)
  390. X    ) ; let
  391. X  ) ; defun load-tpl-file
  392. X
  393. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  394. X
  395. X(defun load-tpl-library (file &optional mode-nm)
  396. X  "Find FILE and add all of the templates in it to the template list.
  397. X    (Uses the 'tpl-load-path value to find the file.)  Optional second
  398. X    argument MODE-NM is used to rebuild the global template list."
  399. X  (interactive "sload-tpl-library: File name? ")
  400. X                    ; Local Variables
  401. X  (let (found head-template-list tail-template-list template-file file-name
  402. X          root-name template-list new-list)
  403. X                    ; Body
  404. X    (setq root-name (tpl-root-of-file-name (file-name-nondirectory file)))
  405. X                    ; Look for file in existing list
  406. X    (setq found nil)
  407. X    (setq head-template-list nil)
  408. X    (setq tail-template-list tpl-local-template-list)
  409. X    (while (and tail-template-list (not found))
  410. X      (setq template-file (car tail-template-list))
  411. X      (setq tail-template-list (cdr tail-template-list))
  412. X      (setq file-name (nth 0 template-file))
  413. X      (if (equal file-name root-name)
  414. X      (setq found t)
  415. X    ; else
  416. X    (setq head-template-list
  417. X          (append head-template-list (list template-file)))
  418. X    ) ; if (equal file-name file)
  419. X      ) ; while (and tail-template-list (not found))
  420. X                    ; If found, query about replacing
  421. X    (if (and found
  422. X         (not (y-or-n-p "File already loaded.  Replace? ")))
  423. X    (error "File already loaded.  Aborted.")
  424. X      ) ; if
  425. X    (setq tpl-local-template-list (append head-template-list tail-template-list))
  426. X                    ; Find template file
  427. X    (setq file (tpl-find-template-file root-name))
  428. X    (if (and (> (length file) 4)
  429. X         (equal (substring file -4) ".elc"))
  430. X    (progn
  431. X      (load file)
  432. X      (setq new-list template-list)
  433. X      ) ; progn
  434. X      ; else
  435. X      (progn
  436. X    (setq new-list (tpl-make-template-list file))
  437. X    ) ; progn
  438. X      ) ; if compiled
  439. X    (setq tpl-local-template-list
  440. X      (append (list new-list)
  441. X          tpl-local-template-list))
  442. X    (if tpl-rebuild-all-templates-template
  443. X    (tpl-make-all-templates-template)
  444. X      ; else
  445. X      (setq tpl-all-templates-template-invalid t)
  446. X      ) ; if
  447. X    (if (interactive-p)
  448. X    (if (y-or-n-p "Rebuild global template list with these new templates? ")
  449. X        (progn
  450. X          (setq mode-nm
  451. X            (read-minibuffer "Mode name for global template list? "))
  452. X          (tpl-rebuild-global-template-list mode-nm new-list)
  453. X          ) ; progn
  454. X      ) ; if
  455. X      ; else
  456. X      (tpl-rebuild-global-template-list mode-nm new-list)
  457. X      ) ; if
  458. X    ) ; let
  459. X  ) ; defun load-tpl-library
  460. X
  461. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  462. X
  463. X(defun next-placeholder ()
  464. X  "Search forward for the next placeholder."
  465. X  (interactive)
  466. X                    ; Local Variables
  467. X  (let (count)
  468. X                    ; Body
  469. X    (if (looking-at tpl-pattern-placeholder)
  470. X    (setq count 2)
  471. X      ; else
  472. X      (setq count 1)
  473. X      ) ; if (looking-at tpl-pattern-placeholder)
  474. X    (re-search-forward tpl-pattern-placeholder (point-max) nil count)
  475. X    (re-search-backward tpl-pattern-placeholder)
  476. X    ) ; let
  477. X  ) ; defun next-placeholder
  478. X
  479. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  480. X
  481. X(defun previous-placeholder ()
  482. X  "Search backward for the previous placeholder."
  483. X  (interactive)
  484. X                    ; Local Variables
  485. X  (let ()
  486. X                    ; Body
  487. X    (re-search-backward tpl-pattern-placeholder)
  488. X    ) ; let
  489. X  ) ; defun previous-placeholder
  490. X
  491. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  492. X
  493. X(defun query-replace-groups (start stop)
  494. X  "Replace some lines after point, beginning with a line that
  495. X    matches START, and ending before a line that matches STOP, with
  496. X    temporary placeholders.  As each match is found, the user
  497. X    must type a character saying what to do with it.  For directions,
  498. X    type \\[help-command] at that time."
  499. X  (interactive "squery-replace-groups starting with: \nsquery-replace-groups starting with %s ending with: ")
  500. X                    ; Local Variables
  501. X  (let ()
  502. X                    ; Body
  503. X    (setq tpl-end-group (concat "^" stop))
  504. X    (perform-replace-tpl
  505. X     (concat "^" start)
  506. X     "placeholder" t nil nil
  507. X     're-search-forward 'tpl-find-end-of-group 'tpl-replace-group
  508. X     'tpl-find-next-group)
  509. X    ) ; let
  510. X  ) ; defun query-replace-groups
  511. X
  512. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  513. X
  514. X(defun query-replace-lines (string)
  515. X  "Replace some lines after point matching leading STRING with
  516. X    temporary placeholders.  As each match is found, the user
  517. X    must type a character saying what to do with it.  For directions,
  518. X    type \\[help-command] at that time."
  519. X  (interactive "squery-replace-lines with leading pattern: ")
  520. X                    ; Local Variables
  521. X  (let ()
  522. X                    ; Body
  523. X    (perform-replace-tpl
  524. X     (concat "^" string)
  525. X     "placeholder" t nil nil
  526. X     're-search-forward 'beginning-of-line 'tpl-replace-line)
  527. X    ) ; let
  528. X  ) ; defun query-replace-lines
  529. X
  530. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  531. X
  532. X(defun region-to-tpl (start stop &optional name file parse)
  533. X  "Create a template with the text between START and STOP.
  534. X    Optionally, call it NAME and put the template in FILE.
  535. X    Optional fifth argument PARSE specifies whether the template
  536. X    should be parsed: if t parse, if nil do not parse, if neither
  537. X    t nor nil ask about parsing."
  538. X  (interactive "r")
  539. X                    ; Local Variables
  540. X  (let (string column text-file template table parse name-place
  541. X           suggestion begin-body)
  542. X                    ; Body
  543. X    (if (not file)
  544. X    (setq file
  545. X          (expand-file-name (read-file-name
  546. X                 (concat "Template file? ("
  547. X                     tpl-new-template-buffer ") ")
  548. X                 nil tpl-new-template-buffer)))
  549. X      ) ; if (not file)
  550. X    (if (and parse (not (equal parse t)))
  551. X    (setq parse (y-or-n-p "region-to-tpl: Parse the template? "))
  552. X      ) ; if
  553. X    (setq string (buffer-substring start stop))
  554. X    (goto-char start)
  555. X    (setq column (current-column))
  556. X    (goto-char stop)
  557. X    (setq text-file (buffer-file-name))
  558. X    (if (not (equal file text-file))
  559. X    (progn
  560. X      (find-file-other-window file)
  561. X      (goto-char (point-min))
  562. X      (open-line 1)
  563. X      (insert tpl-begin-template-definition " ")
  564. X      (setq name-place (point))
  565. X      (insert " ")
  566. X      (if parse
  567. X          (insert tpl-sequence-type)
  568. X        (insert tpl-string-type)
  569. X        ) ; if parse
  570. X      (beginning-of-line nil)
  571. X      (delete-char 1)        ; Remove regexp anchor
  572. X      (setq name-place (1- name-place))
  573. X      (end-of-line nil)
  574. X      (newline)
  575. X      (insert tpl-begin-template-body)
  576. X      (newline)
  577. X      (beginning-of-line 0)
  578. X      (delete-char 1)        ; Remove regexp anchor
  579. X      (beginning-of-line 2)
  580. X                    ; Insert body of template
  581. X      (setq begin-body (point))
  582. X      (insert string)
  583. X      (newline)
  584. X                    ; Fix indentation
  585. X      (indent-rigidly begin-body (point) (- 0 column))
  586. X      (insert tpl-end-template-body)
  587. X      (newline)
  588. X      (beginning-of-line 0)
  589. X      (delete-char 1)        ; Remove regexp anchor
  590. X      (goto-char name-place)
  591. X      (if (not name)
  592. X          (if tpl-get-placeholder-name-in-context
  593. X          (progn
  594. X            (if tpl-form-placeholder-name-from-context
  595. X            (setq suggestion tpl-formed-placeholder-name)
  596. X              ; else
  597. X              (progn
  598. X            (setq suggestion tpl-next-placeholder-name)
  599. X            (tpl-increment-next-placeholder-name)
  600. X            ) ; progn
  601. X              ) ; if tpl-form-placeholder-name-from-context
  602. X            (insert suggestion)
  603. X            (if tpl-query-flag
  604. X            (progn
  605. X              (search-backward suggestion)
  606. X              (setq name
  607. X                (sym-read-string "Placeholder name? "
  608. X                         suggestion))
  609. X              (if (equal (length name) 0)
  610. X                  (progn
  611. X                (setq name suggestion)
  612. X                ) ; progn
  613. X                ) ; if
  614. X              ) ; progn
  615. X              ; else
  616. X              (setq name suggestion)
  617. X              ) ; if tpl-query-flag
  618. X            ) ; progn
  619. X        ; else
  620. X        (progn
  621. X          (setq name (tpl-get-placeholder-name))
  622. X          (insert name)
  623. X          ) ; progn
  624. X        ) ; if tpl-get-placeholder-name-in-context
  625. X        ; else
  626. X        (insert name)
  627. X        ) ; if (not-name)
  628. X      ) ; progn
  629. X      ; else
  630. X      (error "Cannot reuse this file for templates!")
  631. X      ) ; if (not (equal file text-file))
  632. X                    ; return
  633. X    name
  634. X    ) ; let
  635. X  ) ; defun region-to-tpl
  636. X
  637. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  638. X
  639. X(defun replace-line-with-placeholder (count &optional name file parse)
  640. X  "Replace the line containing point with a placeholder.
  641. X    Prefix argument COUNT gives number of lines
  642. X    (ending with current line).  Optional second argument NAME is used
  643. X    for placeholder name.  Optional third argument FILE is used for
  644. X    file to store template.  Optional fourth argument PARSE
  645. X    specifies whether template should be parsed.  (See 'region-to-tpl
  646. X    for interpretation.)"
  647. X  (interactive "p")
  648. X                    ; Local Variables
  649. X  (let (start)
  650. X                    ; Body
  651. X    (if (interactive-p)
  652. X    (progn
  653. X      (setq parse "ask")
  654. X      (setq file "new.tpl")
  655. X      ) ; progn
  656. X      ) ; if
  657. X    (setq count (1- count))
  658. X    (forward-line (* count -1))
  659. X    (setq start (point))
  660. X    (forward-line count)
  661. X    (end-of-line nil)
  662. X    (replace-region-with-placeholder start (point) name file parse)
  663. X    ) ; let
  664. X  ) ; defun replace-line-with-placeholder
  665. X
  666. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  667. X
  668. X(defun replace-region-with-placeholder (start stop &optional name file parse)
  669. X  "Replace the region between START and STOP with a placeholder.
  670. X    Optionally, call it NAME and put the template in FILE.
  671. X    Optional fifth argument PARSE specifies whether template
  672. X    should be parsed.  (See 'region-to-tpl for interpretation.)"
  673. X  (interactive "r")
  674. X                    ; Local Variables
  675. X  (let (start-marker stop-marker)
  676. X                    ; Body
  677. X    (if (interactive-p)
  678. X    (progn
  679. X      (setq parse "ask")
  680. X      (setq file "new.tpl")
  681. X      ) ; progn
  682. X      ) ; if
  683. X    (if (> (- stop start) 0)
  684. X    (progn
  685. X      (save-window-excursion
  686. X        (setq start-marker (make-marker))
  687. X        (set-marker start-marker start)
  688. X        (setq stop-marker (make-marker))
  689. X        (set-marker stop-marker stop)
  690. X        (setq name (region-to-tpl start stop name file parse))
  691. X        (if tpl-auto-save-new-templates
  692. X        (save-buffer)
  693. X          ) ; if tpl-auto-save-new-templates
  694. X        ) ; save-window-excursion
  695. X      (delete-region (marker-position start-marker)
  696. X             (marker-position stop-marker))
  697. X      (unwind-protect
  698. X          (if tpl-auto-load-new-templates
  699. X          (load-tpl-buffer (buffer-name (get-file-buffer file)))
  700. X        ) ; if
  701. X        (goto-char (marker-position start-marker))
  702. X        (set-marker start-marker nil)
  703. X        (set-marker stop-marker nil)
  704. X        (insert-before-markers
  705. X         tpl-begin-placeholder name tpl-end-placeholder))
  706. X      ) ; progn
  707. X      ; else
  708. X      (insert-before-markers
  709. X       tpl-begin-placeholder name tpl-end-placeholder)
  710. X      ) ; if (> (- stop start) 0)
  711. X    ) ; let
  712. X  ) ; defun replace-region-with-placeholder
  713. X
  714. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  715. X
  716. X(defun rewrap-template-around-point ()
  717. X  "Unwrap FIRST template around point and wrap with SECOND.
  718. X    Template names are prompted for with completing-read.
  719. X    A side effect of this function is to push-mark at the beginning of the
  720. X    enclosed region."
  721. X  (interactive)
  722. X                    ; Local Variables
  723. X  (let (name-list first second)
  724. X                    ; Body
  725. X                    ; Build completion list
  726. X    (setq name-list (tpl-make-completion-list))
  727. X                    ; Query for name to unwrap
  728. X    (setq first
  729. X      (completing-read "rewrap-template: Name of enclosing template? "
  730. X               name-list nil t nil))
  731. X                    ; Query for name to wrap
  732. X    (setq second
  733. X      (completing-read "rewrap-template: Name of new template? "
  734. X               name-list nil t nil))
  735. X    (tpl-unwrap-template first t)
  736. X    (tpl-wrap-template (mark) (point) second)
  737. X    ) ; let
  738. X  ) ; defun rewrap-template-around-point
  739. X
  740. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  741. X
  742. X(defun tpl-recompile-templates (template-dir)
  743. X  "Compile a standard list of templates in TEMPLATE-DIR."
  744. X  (interactive "Dtpl-recompile-templates: Template directory? ")
  745. X                    ; Local Variables
  746. X  (let (prefix)
  747. X                    ; Body
  748. X    (autoload 'awk-mode "awk")
  749. X    (autoload 'bib-mode "bib")
  750. X    (autoload 'pascal-mode "pascal")
  751. X    (setq prefix template-dir)
  752. X    (if (not (equal (substring prefix -1) "/"))
  753. X    (setq prefix (concat prefix "/"))
  754. X      ) ; if
  755. X    (if (not template-mode)
  756. X    (template-mode)
  757. X      ) ; if
  758. X    (compile-templates (concat prefix "generic.tpl"))
  759. X    (awk-mode)
  760. X    (template-mode)
  761. X    (compile-templates (concat prefix "awk.tpl"))
  762. X    (bib-mode)
  763. X    (template-mode)
  764. X    (compile-templates (concat prefix "bib.tpl"))
  765. X    (c-mode)
  766. X    (template-mode)
  767. X    (compile-templates (concat prefix "c.tpl"))
  768. X    (emacs-lisp-mode)
  769. X    (template-mode)
  770. X    (compile-templates (concat prefix "elisp.tpl"))
  771. X    (latex-mode)
  772. X    (template-mode)
  773. X    (compile-templates (concat prefix "latex.tpl"))
  774. X    (pascal-mode)
  775. X    (template-mode)
  776. X    (compile-templates (concat prefix "pascal.tpl"))
  777. X    (scribe-mode)
  778. X    (template-mode)
  779. X    (compile-templates (concat prefix "scribe.tpl"))
  780. X    (texinfo-mode)
  781. X    (template-mode)
  782. X    (compile-templates (concat prefix "texinfo.tpl"))
  783. X  ) ; let
  784. X) ; defun tpl-recompile-templates
  785. X
  786. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  787. X
  788. X(defun unwrap-template-around-point (arg)
  789. X  "Complete template name and call tpl-unwrap-template.  Prefix argument
  790. X    ARG non-nil causes the mark to be set at the beginning of the resulting
  791. X    region."
  792. X  (interactive "P")
  793. X                    ; Local Variables
  794. X  (let (name name-list)
  795. X                    ; Body
  796. X                    ; Build completion list
  797. X    (setq name-list (tpl-make-completion-list))
  798. X                    ; Query for name and unwrap
  799. X    (setq name
  800. X      (completing-read "unwrap-template-around-point: Name of template? "
  801. X               name-list nil t nil))
  802. X    (tpl-unwrap-template name arg)
  803. X    ) ; let
  804. X  ) ; defun unwrap-template-around-point
  805. X
  806. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  807. X
  808. X(defun wrap-template-around-line (count)
  809. X  "Replace COUNT lines including point with TEMPLATE,
  810. X    reinserting the replaced line at the destination placeholder.
  811. X    Prefix argument indicates number of lines to wrap.
  812. X    Second argument, TEMPLATE, is read with completing-read."
  813. X  (interactive "p")
  814. X                    ; Local Variables
  815. X  (let (start)
  816. X                    ; Body
  817. X    (setq count (1- count))
  818. X    (forward-line (* count -1))
  819. X    (beginning-of-line nil)
  820. X    (setq start (point))
  821. X    (forward-line count)
  822. X    (end-of-line nil)
  823. X    (wrap-template-around-region start (point))
  824. X    ) ; let
  825. X  ) ; defun wrap-template-around-line
  826. X
  827. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  828. X
  829. X(defun wrap-template-around-region (start stop)
  830. X  "Replace the region between START and STOP with TEMPLATE,
  831. X    reinserting the replaced region at the destination placeholder.
  832. X    The region is indented rigidly at its insertion column.
  833. X    The third argument, TEMPLATE, is read with completing-read."
  834. X  (interactive "r")
  835. X                    ; Local Variables
  836. X  (let (name-list template)
  837. X                    ; Body
  838. X    (setq name-list (tpl-make-completion-list))
  839. X    (setq template (completing-read "wrap-template: Name of template? "
  840. X                    name-list nil t nil))
  841. X    (tpl-wrap-template start stop template)
  842. X    ) ; let
  843. X  ) ; defun wrap-template-around-region
  844. X
  845. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  846. X
  847. X(defun wrap-template-around-word (count)
  848. X  "Replace COUNT words before point with TEMPLATE,
  849. X    reinserting the replaced word at the destination placeholder.
  850. X    Prefix argument indicates number of words to wrap.
  851. X    Second argument, TEMPLATE, is read with completing-read."
  852. X  (interactive "p")
  853. X                    ; Local Variables
  854. X  (let (start)
  855. X                    ; Body
  856. X    (forward-word (* count -1))
  857. X    (setq start (point))
  858. X    (forward-word count)
  859. X    (wrap-template-around-region start (point))
  860. X    ) ; let
  861. X  ) ; defun wrap-template-around-word
  862. X
  863. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  864. X
  865. X(tpl-initialize-modes)
  866. X
  867. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  868. X
  869. X;;; end of template.el
  870. SHAR_EOF
  871. if test 26969 -ne "`wc -c < 'template.el'`"
  872. then
  873.     echo shar: "error transmitting 'template.el'" '(should have been 26969 characters)'
  874. fi
  875. fi
  876. echo shar: "extracting 'tplvars.el'" '(11467 characters)'
  877. if test -f 'tplvars.el'
  878. then
  879.     echo shar: "will not over-write existing file 'tplvars.el'"
  880. else
  881. sed 's/^X//' << \SHAR_EOF > 'tplvars.el'
  882. X;;; tplvars.el -- Variables for template-mode.
  883. X;;; Copyright (C) 1987 Mark A. Ardis.
  884. X
  885. X(provide 'tplvars)
  886. X
  887. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  888. X;;; User Options
  889. X
  890. X(defvar tpl-ask-expansion-depth 1
  891. X  "*Depth of recursive placeholder expansions at which to start asking
  892. X    whether to expand.  Possible values are:
  893. X      -1  delete all placeholders
  894. X    0  don't expand or delete placeholders---leave them alone
  895. X    1  ask about expansion at level 1
  896. X    n  ask about expansion at level n of expanding
  897. X      Defaults to 1, which means always ask."
  898. X) ; tpl-ask-expansion-depth
  899. X
  900. X(defvar tpl-auto-load-new-templates nil
  901. X  "*If non-nil load new templates after creating them with
  902. X    'replace-wtih-placeholder.  Otherwise, loading must be done
  903. X    by invoking 'load-tpl-file.  Defaults to nil."
  904. X) ; tpl-auto-load-new-templates
  905. X
  906. X(defvar tpl-auto-save-new-templates nil
  907. X  "*If non-nil save new templates after creating them with
  908. X    'replace-wtih-placeholder.  Otherwise, saving must be done
  909. X    by invoking 'save-buffer.  Defaults to nil."
  910. X) ; tpl-auto-save-new-templates
  911. X
  912. X(defvar tpl-auto-template-alist nil
  913. X  "*Global Alist of major modes and their associated template files.
  914. X    Initialized by 'tpl-initialize-modes'."
  915. X) ; tpl-auto-template-alist
  916. X
  917. X(defvar tpl-begin-placeholder "<"
  918. X  "*Regular expression for beginning of placeholder."
  919. X) ; tpl-begin-placeholder
  920. X
  921. X(defvar tpl-begin-template-body "^:begin"
  922. X  "*Regular expression for beginning of template body."
  923. X) ; tpl-begin-template-body
  924. X(make-variable-buffer-local 'tpl-begin-template-body)
  925. X(setq-default tpl-begin-template-body "^:begin")
  926. X
  927. X(defvar tpl-begin-template-definition "^Template"
  928. X  "*Regular expression for beginning of template definition."
  929. X) ; tpl-begin-template-definition
  930. X(make-variable-buffer-local 'tpl-begin-template-definition)
  931. X(setq-default tpl-begin-template-definition "^Template")
  932. X
  933. X(defvar tpl-destination-symbol "POINT"
  934. X  "*Special symbol used as placeholder as location for point
  935. X    after expanding a template."
  936. X) ; tpl-destination-symbol
  937. X
  938. X(defvar tpl-display-begin ">>"
  939. X  "*Delimiter marking beginning of a selected placeholder."
  940. X) ; tpl-display-begin
  941. X
  942. X(defvar tpl-display-end "<<"
  943. X  "*Delimiter marking end of a selected placeholder."
  944. X) ; tpl-display-end
  945. X
  946. X(defvar tpl-end-placeholder ">"
  947. X  "*Regular expression for end of placeholder."
  948. X) ; tpl-end-placeholder
  949. X
  950. X(defvar tpl-end-template-body "^:end"
  951. X  "*Regular expression for end of template body."
  952. X) ; tpl-end-template-body
  953. X(make-variable-buffer-local 'tpl-end-template-body)
  954. X(setq-default tpl-end-template-body "^:end")
  955. X
  956. X(defvar tpl-fill-while-unscanning nil
  957. X  "*If non-nil, use whatever fill mode is in effect while unscanning
  958. X    (inserting) templates.  Defaults to nil, which ensures that template
  959. X    formats are not disturbed by context."
  960. X) ; tpl-fill-while-unscanning
  961. X
  962. X(defvar tpl-form-placeholder-name-from-context nil
  963. X  "*Option to generate placeholder names by looking for the first symbol
  964. X    after point.  Defaults to nil, which means use temporary names instead."
  965. X) ; tpl-form-placeholder-name-from-context
  966. X
  967. X(defvar tpl-function-type "Function"
  968. X  "*Name of function-type template type."
  969. X) ; tpl-function-type
  970. X
  971. X(defvar tpl-get-placeholder-name-in-context t
  972. X  "*If non-nil allow the user to type in the placeholder name within
  973. X    the context of the template definition.  Otherwise, use temporary
  974. X    names.  Defaults to t."
  975. X) ; tpl-get-placeholder-name-in-context
  976. X
  977. X(defvar tpl-include-prefix-in-groups t
  978. X  "*Option to include the prefix string (used to find the beginning of
  979. X    a group) in the group."
  980. X) ; tpl-include-prefix-in-groups
  981. X
  982. X(defvar tpl-indentation-size 2
  983. X  "*Size of indentation units in columns."
  984. X) ; tpl-indentation-size
  985. X(make-variable-buffer-local 'tpl-indentation-size)
  986. X(setq-default tpl-indentation-size 2)
  987. X
  988. X(defvar tpl-keep-optional-placeholders "ask"
  989. X  "*Option to determine processing of optional placeholders in template-mode.
  990. X    If t, then always keep them.  If nil, then always delete them.  If neither
  991. X    t nor nil, then always ask."
  992. X) ; tpl-keep-optional-placeholders
  993. X
  994. X(defvar tpl-lexical-type "Lexical"
  995. X  "*Name of lexical-type template type."
  996. X) ; tpl-lexical-type
  997. X
  998. X(defvar tpl-literal-whitespace nil
  999. X  "*If non-nil leave leading whitespace in templates as-is.
  1000. X    Otherwise, calculate relative indentation units (see
  1001. X    'tpl-indentation-size' variable).  Defaults to nil."
  1002. X) ; tpl-literal-whitespace
  1003. X
  1004. X(defvar tpl-load-path (list nil "/faculty/ardis/Gnu/Template/Templates")
  1005. X  "*List of directories to search for template files to load.
  1006. X    Each element is a string (directory name) or nil (try default directory).
  1007. X    Use 'template-mode-load-hook to change this value."
  1008. X) ; tpl-load-path
  1009. X
  1010. X(defvar tpl-new-template-buffer "new.tpl"
  1011. X  "*Buffer containing new templates."
  1012. X) ; tpl-new-template-buffer
  1013. X
  1014. X(defvar tpl-next-placeholder-number 1
  1015. X  "*Counter used to generate unique temporary placeholder names."
  1016. X) ; tpl-next-placeholder-number
  1017. X
  1018. X(defvar tpl-pattern-optional "#"
  1019. X  "*Regular expression for all optional placeholders."
  1020. X) ; tpl-pattern-optional
  1021. X
  1022. X(defvar tpl-pattern-other "."
  1023. X  "*Regular expression for all other tokens."
  1024. X) ; tpl-pattern-other
  1025. X
  1026. X(defvar tpl-pattern-placeholder nil
  1027. X  "*Regular expression for placeholder."
  1028. X) ; tpl-pattern-placeholder
  1029. X
  1030. X(defvar tpl-pattern-punctuation "\\s.+"
  1031. X  "*Regular expression for at least one punctuation character."
  1032. X) ; tpl-pattern-punctuation
  1033. X
  1034. X(defvar tpl-pattern-string ".*"
  1035. X  "*Regular expression for any string."
  1036. X) ; tpl-pattern-string
  1037. X
  1038. X(defvar tpl-pattern-symbol "\\(\\sw\\|\\s_\\)+"
  1039. X  "*Regular expression for at least one symbol character."
  1040. X) ; tpl-pattern-symbol
  1041. X
  1042. X(defvar tpl-pattern-whitespace "[     ]+"
  1043. X  "*Regular expression for at least one whitespace character."
  1044. X) ; tpl-pattern-whitespace
  1045. X
  1046. X(defvar tpl-pattern-word "\\sw+"
  1047. X  "*Regular expression for at least one word character."
  1048. X) ; tpl-pattern-word
  1049. X
  1050. X(defvar tpl-rebuild-all-templates-template nil
  1051. X  "*If non-nil rebuild the list of all templates after invoking
  1052. X    template-mode and after loading new templates.  Otherwise, do not
  1053. X    (improves performance of starting up).  Defaults to nil."
  1054. X) ; tpl-rebuild-all-templates-template
  1055. X
  1056. X(defvar tpl-repetition-type "Repetition"
  1057. X  "*Name of repetition-type template type."
  1058. X) ; tpl-repetition-type
  1059. X
  1060. X(defvar tpl-save-identifier-file nil
  1061. X  "*Option to save identifier table in a separate file.  Defaults
  1062. X    to nil, which means save only in a buffer."
  1063. X) ; tpl-save-identifier-file
  1064. X
  1065. X(defvar tpl-selection-type "Selection"
  1066. X  "*Name of selection-type template type."
  1067. X) ; tpl-selection-type
  1068. X
  1069. X(defvar tpl-sep-placeholder ":"
  1070. X  "*Regular expression for placeholder body separator."
  1071. X) ; tpl-sep-placeholder
  1072. X
  1073. X(defvar tpl-sequence-type "Sequence"
  1074. X  "*Name of sequence-type template type."
  1075. X) ; tpl-sequence-type
  1076. X
  1077. X(defvar tpl-string-type "String"
  1078. X  "*Name of string-type template type."
  1079. X) ; tpl-string-type
  1080. X
  1081. X(defvar tpl-temporary-placeholder-name "TEMP"
  1082. X  "*Root of temporary placeholder names."
  1083. X) ; tpl-temporary-placeholder-name
  1084. X
  1085. X(defvar tpl-verify-end-of-group nil
  1086. X  "*Option to verify (by positioning point) the end of each group
  1087. X    of lines in 'query-replace-groups."
  1088. X) ; tpl-verify-end-of-group
  1089. X
  1090. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1091. X;;; Global Variables
  1092. X
  1093. X(defvar lex-patterns nil
  1094. X  "A list of regular expressions to be used in recognizing tokens."
  1095. X) ; lex-patterns
  1096. X
  1097. X(defvar string-patterns nil
  1098. X  "A list of string patterns to be used in recognizing tokens."
  1099. X) ; string-patterns
  1100. X
  1101. X(defvar template-mode nil
  1102. X  "Minor mode symbol."
  1103. X) ; template-mode
  1104. X(make-variable-buffer-local 'template-mode)
  1105. X
  1106. X(defvar template-mode-map nil
  1107. X  "Keymap for template-mode."
  1108. X) ; template-mode-map
  1109. X
  1110. X(defvar tpl-all-templates-file "ALLTEMPLATES"
  1111. X  "Name of dummy template file for all-templates-template."
  1112. X) ; tpl-all-templates-name
  1113. X
  1114. X(defvar tpl-all-templates-name "ALLTEMPLATES"
  1115. X  "Name of special template that is a selection of all other templates."
  1116. X) ; tpl-all-templates-name
  1117. X
  1118. X(defvar tpl-all-templates-template-invalid t
  1119. X  "Flag to indicate validity of all-templates-template."
  1120. X) ; tpl-all-templates-template-invalid
  1121. X
  1122. X(defvar tpl-begin-optional nil
  1123. X  "Regular expression for beginning of optional placeholder."
  1124. X) ; tpl-begin-optional
  1125. X
  1126. X(defvar tpl-buffer
  1127. X  "Current template buffer."
  1128. X) ; tpl-buffer
  1129. X
  1130. X(defvar tpl-comment-level 100
  1131. X  "Special value indicating alignment on comment column."
  1132. X) ; tpl-comment-level
  1133. X
  1134. X(defvar tpl-destination-marker (make-marker)
  1135. X  "Location (a marker) to leave point after expanding placeholder."
  1136. X) ; tpl-destination-marker
  1137. X(make-variable-buffer-local 'tpl-destination-marker)
  1138. X(setq-default tpl-destination-marker (make-marker))
  1139. X
  1140. X(defvar tpl-destination-needed nil
  1141. X  "Boolean flag used to signal whether a destination for point (after
  1142. X    expanding a placeholder) has been found yet."
  1143. X) ; tpl-destination-needed
  1144. X
  1145. X(defvar tpl-destination-placeholder nil
  1146. X  "Special placeholder used to place point after expanding a template."
  1147. X) ; tpl-destination-placeholder
  1148. X
  1149. X(defvar tpl-end-group nil
  1150. X  "Global variable to hold pattern for end of group."
  1151. X) ; tpl-end-group
  1152. X
  1153. X(defvar tpl-expansion-depth 1
  1154. X  "Current depth of recursive calls to expand placeholders.
  1155. X    Compared to tpl-ask-expansion-depth."
  1156. X) ; tpl-expansion-depth
  1157. X(make-variable-buffer-local 'tpl-expansion-depth)
  1158. X(setq-default tpl-expansion-depth 1)
  1159. X
  1160. X(defvar tpl-formed-placeholder-name nil
  1161. X  "Value formed by searching for next symbol after point."
  1162. X) ; tpl-formed-placeholder-name
  1163. X
  1164. X(defvar tpl-global-template-list nil
  1165. X  "Global Alist of major modes and their associated templates."
  1166. X) ; tpl-global-template-list
  1167. X
  1168. X(defvar tpl-indentation-type 'indentation
  1169. X  "Type of indentation terminals."
  1170. X) ; tpl-indentation-type
  1171. X
  1172. X(defvar tpl-local-template-list nil
  1173. X  "List of all templates and their tree values."
  1174. X) ; tpl-local-template-list
  1175. X(make-variable-buffer-local 'tpl-local-template-list)
  1176. X
  1177. X(defvar tpl-menu-buffer "Menu"
  1178. X  "Buffer used for making selections of templates."
  1179. X) ; tpl-menu-buffer
  1180. X
  1181. X(defvar tpl-newline-token nil
  1182. X  "Token indicating presence of a newline."
  1183. X) ; tpl-newline-token
  1184. X
  1185. X(defvar tpl-newline-type 'newline
  1186. X  "Type of newline terminals."
  1187. X) ; tpl-newline-type
  1188. X
  1189. X(defvar tpl-next-placeholder-name (concat tpl-temporary-placeholder-name
  1190. X                    tpl-next-placeholder-number)
  1191. X  "Next unique name for temporary placeholder."
  1192. X) ; tpl-next-placeholder-number
  1193. X
  1194. X(defvar tpl-optional-type 'optional
  1195. X  "Type of optional placeholders."
  1196. X) ; tpl-optional-type
  1197. X
  1198. X(defvar tpl-other-type 'other
  1199. X  "Type of other terminals."
  1200. X) ; tpl-other-type
  1201. X
  1202. X(defvar tpl-placeholder-type 'placeholder
  1203. X  "Type of all placeholders."
  1204. X) ; tpl-placeholder-type
  1205. X
  1206. X(defvar tpl-punctuation-type 'punctuation
  1207. X  "Type of punctuation terminals."
  1208. X) ; tpl-punctuation-type
  1209. X
  1210. X(defvar tpl-query-flag t
  1211. X  "If non-nil query about placeholder names."
  1212. X) ; tpl-query-flag
  1213. X
  1214. X(defvar tpl-saved-map nil
  1215. X  "Local keymap to restore when turning off template-mode."
  1216. X) ; tpl-saved-map
  1217. X(make-variable-buffer-local 'tpl-saved-map)
  1218. X
  1219. X(defvar tpl-terminal-type 'terminal
  1220. X  "Type of all literal strings."
  1221. X) ; tpl-terminal-type
  1222. X
  1223. X(defvar tpl-textlong-buffer "Textlong"
  1224. X  "Buffer used for creating textlong values."
  1225. X) ; tpl-textlong-buffer
  1226. X
  1227. X(defvar tpl-whitespace-type 'whitespace
  1228. X  "Type of whitespace terminals."
  1229. X) ; tpl-whitespace-type
  1230. X
  1231. X(defvar tpl-word-type 'word
  1232. X  "Type of word terminals."
  1233. X) ; tpl-word-type
  1234. X
  1235. X(defvar tpl-work-buffer "Work"
  1236. X  "Buffer used for constructing temporary objects."
  1237. X) ; tpl-work-buffer
  1238. X
  1239. X;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  1240. X
  1241. X;;; end of tplvars.el
  1242. SHAR_EOF
  1243. if test 11467 -ne "`wc -c < 'tplvars.el'`"
  1244. then
  1245.     echo shar: "error transmitting 'tplvars.el'" '(should have been 11467 characters)'
  1246. fi
  1247. fi
  1248. exit 0
  1249. #    End of shell archive
  1250.  
  1251.  
  1252.